/********************* 内存管理 ***********************/
#include<iostream>
// #include<cstdlib>
using namespace std;

// int main()
// {
//     char s[] = "abcd";
//     const char* pc = "abcd";
//     int* pi = (int*)malloc(sizeof(int) * 10);
//     return 0;
// }

// int main()
// {
//     int* p = new int;  // 动态申请一个int变量
//     delete p;          // 释放资源

//     int* pa = new int[10];  // 动态申请一个个int数组，长度为10
//     delete[] pa;            // 释放资源，数组要在前面加上[]。（直接写成delete pa）
//     return 0;
// }

// class A
// {
//     int _a1;
//     int _a2;
// public:
//     A(int a = 10) 
//         :_a1(a)
//         ,_a2(a)
//     { cout << "A()" << endl; }

//     A(int a1, int a2) 
//         :_a1(a1)
//         ,_a2(a2)
//     { cout << "A(int a1, int a2)" << endl; }

//     ~A() { cout << "~A()" << endl; }

//     void Print() { cout << _a1 << ' ' << _a2 << endl; }
// };

// class A
// {
//     int _a;
// public:
//     A(int a = 10) 
//         :_a(a)
//     { cout << "A()" << endl; }
//     ~A() { cout << "~A()" << endl; }

//     void Print() { cout << _a << endl; }
// };
// int main()
// {
//     exit(-10);
//     // int* p = new int[10];
//     // free(p);
    
//     // A* pa = new A[10];
//     // free(pa);
//     return 0;
// }

// int main()
// {
//     int* a1 = (int*)malloc(sizeof(int) * 5);
//     a1 = (int*)realloc(a1, sizeof(int) * 10); // 扩成10个

//     int* a2 = new int[5];
//     delete[] a2;
//     a2 = new int[10];
//     return 0;
// }

// int main()
// {
//     A* pa = new A[4] { 1, {21,22}, A(2), A(33,44) };
//     // 第一个：单参数隐式类型转换；第二个：多参数隐式类型转换；后面两个：匿名对象
//     for(int i = 0; i < 4; i++)
//         pa[i].Print();
//     return 0;
// }

// int main()
// {
//     A* pa = new A;  // 申请好空间后，会调用默认构造
//     pa->Print();
//     delete pa;      // 先析构，再释放空间

//     cout << endl;

//     A* pa1 = new A(222);    // 申请好空间后，会调用默认构造
//     pa1->Print();
//     delete pa1;

//     A* pa2 = new A[4]{ 1,2,3,4 };   // 这里其实是隐式类型转换，对于第一个元素，相当于pa2[0] = 1;
//     for(int i = 0; i < 4; i++)
//         pa2[i].Print();
//     delete[] pa2;
//     return 0;
// }


/********************* 模板初阶 ***********************/

// void Swap(int& a, int& b) { int t = a; a = b, b = t; }
// void Swap(double& a, double& b) { double t = a; a = b, b = t; }
// void Swap(char& a, char& b) { char t = a; a = b, b = t; }
// // ...

// template<typename T>
// void Swap(T& a, T&b)
// {
//     T tmp = a;
//     a = b;
//     b = tmp;
// }



// int main()
// {
//     int a1 = 1, a2 = 2;
//     Swap(a1, a2);

//     double d1 = 3.1, d2 = 2.1;
//     Swap(d1, d2);

//     char c1 = 'a', c2 = 'z';
//     Swap(c1, c2);

//     Swap(a1, c1);
//     return 0;
// }


// template<class T>
// T Add(const T& t1, const T& t2)
// {
//     return t1 + t2;
// }

// int main()
// {
//     double d1 = 3.14, d2 = 2.53;
//     int c = Add<int>(d1, d2); // 显式实例化，明确表明将函数里的T替换成int
//     cout << c << endl;      // 输出 5
//     return 0;
// }


// template<class T>
// T* func(int n)
// {
//     T* p = new T[n];
//     return p;
// }

// int main()
// {
//     // int* a = func(5); // err 无法推演模板参数类型
//     int* a = func<int>(5);
//     return 0;
// }


// template<class T>
// T Add(const T& t1, const T& t2)
// {
//     cout << "T Add(const T& t1, const T& t2)" << endl;
//     return t1 + t2;
// }

// int Add(int t1, int t2)
// {
//     cout << "int Add(int t1, int t2)" << endl;
//     return t1 + t2;
// }
// int main()
// {
//     int a = 1, b = 2;
//     int c = Add(a, b);  // 调用非模板函数
//     int d = Add<int>(a, b); // 调用编译器特化的Add版本
//     return 0;
// }

// template<class T>
// class A
// {
//     T _t;
// public:
//     void func()
//     {
//         cout << typeid(_t).name() << endl;
//     }
// };

// int main()
// {
//     A<int> a1;
//     a1.func();
//     return 0;
// }


// int main()
// {
//     int* p = new int;  // 动态申请一个int变量。等价于(int*)malloc(sizeof(int));
//     delete p;          // 释放资源

//     int* pa = new int[4];  // 动态申请一个int数组，长度为4。等价于(int*)malloc(sizeof(int) * 4);
//     delete[] pa;            // 释放资源，数组要在前面加上[]。（直接写成delete pa在有些编译器可能会出问题）

// 	// 申请n个空间
//     int n = 20;
//     int* a = new int[n];
//     delete[] a;
    
//     int* p1 = new int(10); // 申请一个int变量, 并将其初始化为10，注意这里是()，[]才是申请10个int
//     int* p2 = new int[4] { 1, 2, 3, 4 }; // 申请一个长度为4的int数组, 并将其初始化为{1,2,3,4}
//     cout << *p1 << endl;
//     for (int i = 0; i < 4; i++) cout << p2[i] << ' ';
//     delete p1;
//     delete[] p2;
//     return 0;
// }

// template<class T>
// class Stack
// {
//     T* _arr;
//     int _top;
//     int _capacity;
// public:
//     Stack(int n = 1000)
//         :_arr(new T[n])    // 就相当于T* _arr = new T[n]
//         ,_top(0)
//         ,_capacity(n)
//     {}
//     ~Stack()
//     {
//         delete[] _arr;
//         _arr = nullptr;
//         _top = _capacity = 0;
//     }
//     // 下面的只实现函数的核心，扩容、判空等等先不考虑
//     void push(const T& x);
//     void pop() { _top--; }
//     bool empty() { return _top == 0; }
//     T top() { return _arr[_top - 1]; }
// };

// int main()
// {
//     Stack<int> st;      // 类模板必须显式实例化！在类名与对象名之间加上尖括号，里面指定模板参数的类型
//     Stack<char> st2;
//     return 0;
// }
// template<class T>
// void Stack<T>::push(const T& x) 
// {
//      _arr[_top++] = x; 
// }
